home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / window / _window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  16.5 KB  |  755 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _window.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include <LEDA/window.h>
  18. #include <math.h>
  19.  
  20.  
  21.  
  22.  
  23. //------------------------------------------------------------------------------
  24. // WINDOW BASICS
  25. //------------------------------------------------------------------------------
  26.  
  27.  
  28. static void window_error_handler(int i, const char* s)
  29. { if (i==0) return;
  30.   panel P;
  31.   P.text_item(string("ERROR(%d): %s",i,s));
  32.   P.button("exit");
  33.   P.button("dump core");
  34.   if (P.open() == 0)
  35.      exit(0);
  36.   else 
  37.      abort();
  38.  }
  39.  
  40. window::window(float width,float height,float xpos,float ypos,const char* label)
  41. : LEDA_WINDOW(width,height,xpos,ypos, label)
  42. { set_error_handler(window_error_handler); }
  43.  
  44. window::window(float width, float height, const char* label)
  45. : LEDA_WINDOW(width,height,label)
  46. { set_error_handler(window_error_handler); }
  47.  
  48. window::window(const char* label) : LEDA_WINDOW(label)
  49. { set_error_handler(window_error_handler); }
  50.  
  51. window::window(int) // do not open
  52. { set_error_handler(window_error_handler); }
  53.  
  54.  
  55.  
  56. //------------------------------------------------------------------------------
  57. // WINDOW OUTPUT
  58. //------------------------------------------------------------------------------
  59.  
  60.  
  61. // pixels
  62.  
  63. void window::draw_pix(double x, double y, color c ) 
  64. { LEDA_WINDOW::draw_pix(x,y,c); }
  65.  
  66. void window::draw_pix(const point& p, color c ) 
  67. { draw_pix(p.xcoord(),p.ycoord(),c); }
  68.  
  69. void window::draw_text(double x, double y, string s, color c)
  70. { LEDA_WINDOW::draw_text(x,y,s,c); }
  71.  
  72. void window::draw_text(const point& p, string s, color c)
  73. { draw_text(p.xcoord(),p.ycoord(),s,c); }
  74.  
  75. void window::draw_ctext(double x, double y, string s, color c)
  76. { LEDA_WINDOW::draw_ctext(x,y,s,c); }
  77.  
  78. void window::draw_ctext(const point& p, string s, color c)
  79. { draw_ctext(p.xcoord(),p.ycoord(),s,c); }
  80.  
  81. // points
  82.  
  83. void window::draw_point(double x0,double y0,color c)
  84. { LEDA_WINDOW::draw_point(x0,y0,c); }
  85.  
  86. void window::draw_point(const point& p,color c)
  87. { draw_point(p.xcoord(),p.ycoord(),c); }
  88.  
  89.  
  90. // segments
  91.  
  92. void window::draw_segment(double x1, double y1, double x2, double y2, color c )
  93. { LEDA_WINDOW::draw_segment(x1,y1,x2,y2,c); }
  94.  
  95. void window::draw_segment(const point& p, const point& q, color c )
  96. { window::draw_segment(p.xcoord(),p.ycoord(),q.xcoord(),q.ycoord(),c); }
  97.  
  98. void window::draw_segment(const segment& s, color c )
  99. { draw_segment(s.start(),s.end(),c); }
  100.  
  101.  
  102. // lines
  103.  
  104.  
  105. void window::draw_line(const line& l, color c )
  106. {
  107.   double a,x0,x1,y0,y1;
  108.  
  109.   if (l.vertical()) 
  110.   { draw_vline(l.x_proj(0),c);
  111.     return;
  112.    }
  113.  
  114.   a = l.slope();
  115.  
  116.   if (fabs(a) < 1)
  117.   { x0 = xmin();
  118.     x1 = xmax();
  119.     y0 = l.y_proj(x0);
  120.     y1 = l.y_proj(x1);
  121.    }
  122.   else
  123.   { y0 = ymin();
  124.     y1 = ymax();
  125.     x0 = l.x_proj(y0);
  126.     x1 = l.x_proj(y1);
  127.    }
  128.  
  129.   LEDA_WINDOW::draw_segment(x0,y0,x1,y1,c);
  130.  
  131. }
  132.  
  133.  
  134. void window::draw_line(const segment& s, color c )
  135. { draw_line(line(s),c); }
  136.  
  137. void window::draw_line(const point& p, const point& q, color c) 
  138. { draw_line(line(p,q),c); }
  139.  
  140. void window::draw_line(double x1, double y1, double x2, double y2, color c )
  141. { draw_line(segment(x1,y1,x2,y2),c); }
  142.  
  143.  
  144. void window::draw_hline(double y, color c )
  145. { LEDA_WINDOW::draw_segment(xmin(),y,xmax(),y,c); }
  146.  
  147. void window::draw_vline(double x, color c )
  148. { LEDA_WINDOW::draw_segment(x,ymin(),x,ymax(),c); }
  149.  
  150.  
  151.  
  152.  
  153. // nodes
  154.  
  155. void window::draw_node(double x0,double y0,color c) 
  156. { LEDA_WINDOW::draw_node(x0,y0,c); }
  157.  
  158. void window::draw_node(const point& p, color c)
  159. { window::draw_node(p.xcoord(),p.ycoord(),c); }
  160.  
  161. void window::draw_filled_node(double x0,double y0,color c)
  162. { LEDA_WINDOW::draw_filled_node(x0,y0,c); }
  163.  
  164. void window::draw_filled_node(const point& p, color c)
  165. { window::draw_filled_node(p.xcoord(),p.ycoord(),c); }
  166.  
  167. void window::draw_text_node(double x,double y,string s,color c)
  168. { LEDA_WINDOW::draw_text_node(x,y,~s,c); }
  169.  
  170. void window::draw_text_node(const point& p ,string s,color c)
  171. { window::draw_text_node(p.xcoord(),p.ycoord(),~s,c); }
  172.  
  173. void window::draw_int_node(double x,double y,int i,color c)
  174. { LEDA_WINDOW::draw_int_node(x,y,i,c); }
  175.  
  176. void window::draw_int_node(const point& p ,int i,color c)
  177. { window::draw_int_node(p.xcoord(),p.ycoord(),i,c); }
  178.  
  179.  
  180. //circles
  181.  
  182. void window::draw_circle(double x,double y,double r,color c)
  183. { LEDA_WINDOW::draw_circle(x,y,r,c); }
  184.  
  185. void window::draw_circle(const point& p,double r,color c)
  186. { LEDA_WINDOW::draw_circle(p.xcoord(),p.ycoord(),r,c); }
  187.  
  188. void window::draw_circle(const circle& C,color c)
  189. { point p = C.center();
  190.   double r = C.radius();
  191.   LEDA_WINDOW::draw_circle(p.xcoord(),p.ycoord(),r,c); 
  192.  }
  193.  
  194.  
  195. // discs
  196.  
  197. void window::draw_disc(double x,double y,double r,color c)
  198. { LEDA_WINDOW::draw_filled_circle(x,y,r,c); }
  199.  
  200. void window::draw_disc(const point& p,double r,color c)
  201. { window::draw_disc(p.xcoord(),p.ycoord(),r,c); }
  202.  
  203.  
  204. void window::draw_disc(const circle& C,color c)
  205. { draw_disc(C.center(),C.radius(),c); }
  206.  
  207.  
  208.  
  209. //ellipses
  210.  
  211. void window::draw_ellipse(double x,double y,double r1,double r2,color c)
  212. { LEDA_WINDOW::draw_ellipse(x,y,r1,r2,c); }
  213.  
  214. void window::draw_ellipse(const point& p, double r1, double r2, color c)
  215. { LEDA_WINDOW::draw_ellipse(p.xcoord(),p.ycoord(),r1,r2,c); }
  216.  
  217. void window::draw_filled_ellipse(double x,double y,double r1,double r2,color c)
  218. { LEDA_WINDOW::draw_filled_ellipse(x,y,r1,r2,c); }
  219.  
  220. void window::draw_filled_ellipse(const point& p, double r1, double r2, color c)
  221. { LEDA_WINDOW::draw_filled_ellipse(p.xcoord(),p.ycoord(),r1,r2,c); }
  222.  
  223.  
  224.  
  225. // arcs
  226.  
  227. void window::draw_arc(const segment& s, double r, color col)
  228. { double d   = s.length()/(2*fabs(r));
  229.   if (d > 1) return;
  230.   double acd = acos(d);
  231.   if (r < 0) 
  232.     { point   m  = s.start().translate(s.angle()-acd,-r);
  233.       segment x(m,s.end());
  234.       LEDA_WINDOW::draw_arc(m.xcoord(),m.ycoord(),-r,-r,x.angle(),M_PI-2*acd,col);
  235.      }
  236.   else 
  237.     { point   m  = s.start().translate(s.angle()+acd,r);
  238.       segment x(m,s.end());
  239.       LEDA_WINDOW::draw_arc(m.xcoord(),m.ycoord(),r,r,x.angle(),2*acd-M_PI,col);
  240.      }
  241.  }
  242.  
  243. void window::draw_arc(double x0,double y0,double x1,double y1,double r,color c)
  244. { draw_arc(segment(x0,y0,x1,y1),r,c); }
  245.  
  246. void window::draw_arc(const point& p, const point& q, double r, color c)
  247. { draw_arc(segment(p,q),r,c); }
  248.  
  249.  
  250.  
  251. void window::draw_arc_arrow(const segment& s, double r, color col)
  252. { double d   = s.length()/(2*r);
  253.   if (d > 1) return;
  254.   point p = draw_arrow_head(s.end(), s.angle() + M_PI/2 - acos(d), col);
  255.   draw_arc(s.start(),p,r,col);
  256.  }
  257.  
  258. void window::draw_arc_arrow(double x0,double y0,double x1,double y1,double r,color c)
  259. { draw_arc_arrow(segment(x0,y0,x1,y1),r,c); }
  260.  
  261. void window::draw_arc_arrow(const point& p, const point& q, double r, color c)
  262. { draw_arc_arrow(segment(p,q),r,c); }
  263.  
  264.  
  265. // polygons
  266.  
  267. void window::draw_polygon(const list<point>& lp, color c)
  268. { int n = lp.length();
  269.   double* X = new double[n];
  270.   double* Y = new double[n];
  271.   n = 0;
  272.   point p;
  273.   forall(p,lp) 
  274.   { X[n] = p.xcoord();
  275.     Y[n] = p.ycoord();
  276.     n++;
  277.    }
  278.   LEDA_WINDOW::draw_polygon(n,X,Y,c);
  279.   delete X;
  280.   delete Y;
  281. }
  282.  
  283. void window::draw_filled_polygon(const list<point>& lp, color c)
  284. { int n = lp.length();
  285.   double* X = new double[n];
  286.   double* Y = new double[n];
  287.   n = 0;
  288.   point p;
  289.   forall(p,lp) 
  290.   { X[n] = p.xcoord();
  291.     Y[n] = p.ycoord();
  292.     n++;
  293.    }
  294.   LEDA_WINDOW::draw_filled_polygon(n,X,Y,c);
  295.   delete X;
  296.   delete Y;
  297. }
  298.  
  299. void window::draw_polygon(const polygon& P, color c )
  300. { draw_polygon(P.vertices(),c); }
  301.  
  302. void window::draw_filled_polygon(const polygon& P,color c )
  303. { draw_filled_polygon(P.vertices(),c); }
  304.  
  305.  
  306.  
  307.  
  308. void window::draw_rectangle(double a, double  b, double c, double d, color col)
  309. { LEDA_WINDOW::draw_rectangle(a,b,c,d,col); }
  310.  
  311. void window::draw_filled_rectangle(double a, double  b, double c, double d, color col)
  312. { LEDA_WINDOW::draw_filled_rectangle(a,b,c,d,col); }
  313.  
  314.  
  315. // functions
  316.  
  317. void window::plot_xy(double x0, double x1, draw_func_ptr f, color c)
  318. { LEDA_WINDOW::plot_xy(x0,x1,f,c); }
  319.  
  320. void window::plot_yx(double y0, double y1, draw_func_ptr f, color c)
  321. { LEDA_WINDOW::plot_yx(y0,y1,f,c); }
  322.  
  323.  
  324.  
  325. // arrows
  326.  
  327. point window::draw_arrow_head(const point& q, double a, color c)
  328. { double X[4];
  329.   double Y[4];
  330.   
  331.   double alpha = a-M_PI; 
  332.  
  333.   double d = 2*((get_line_width()+2)/3.0)/scale();
  334.  
  335.   point l = q.translate(alpha+M_PI/6, 7*d);
  336.   point m = q.translate(alpha,        4*d);
  337.   point r = q.translate(alpha-M_PI/6, 7*d);
  338.  
  339.  
  340.   X[0] = q.xcoord();
  341.   Y[0] = q.ycoord();
  342.   X[1] = l.xcoord();
  343.   Y[1] = l.ycoord();
  344.   X[2] = m.xcoord();
  345.   Y[2] = m.ycoord();
  346.   X[3] = r.xcoord();
  347.   Y[3] = r.ycoord();
  348.  
  349.   LEDA_WINDOW::draw_filled_polygon(4,X,Y,c);
  350.   return m;
  351. }
  352.  
  353.  
  354. void window::draw_arrow(const segment& s, color c)
  355. { point q = draw_arrow_head(s.end(),s.angle(),c);
  356.   draw_segment(s.start(),q,c);
  357. }
  358.  
  359. void window::draw_arrow(const point& p, const point& q, color c)
  360. { draw_arrow(segment(p,q),c); }
  361.  
  362. void window::draw_arrow(double x0, double y0, double x1, double y1, color c)
  363. { draw_arrow(segment(x0,y0,x1,y1),c); }
  364.  
  365.  
  366.  
  367.  
  368.  
  369. // edges
  370.  
  371. void window::draw_edge(double x0, double y0, double x1, double y1, color c)
  372. { LEDA_WINDOW::draw_edge(x0,y0,x1,y1,c); }
  373.  
  374. void window::draw_edge(const point& p, const point& q, color c)
  375. { draw_edge(p.xcoord(),p.ycoord(),q.xcoord(),q.ycoord(),c); }
  376.  
  377. void window::draw_edge(const segment& s, color c)
  378. { draw_edge(s.start(),s.end(),c); }
  379.  
  380.  
  381. void window::draw_arc_edge(double x0, double y0, double x1, double y1, color c)
  382. { draw_arc_edge(segment(x0,y0,x1,y1),c); }
  383.  
  384. void window::draw_arc_edge(const point& p, const point& q, double r, color c)
  385. { draw_arc_edge(segment(p,q),r,c); }
  386.  
  387. void window::draw_arc_edge(const segment& s, double r, color c)
  388. { double R = get_node_width()/scale();
  389.   double d = s.length()/(2*r);
  390.   if (d > 1) return;
  391.   point p = s.start().translate(s.angle() - M_PI/2 + acos(d), R);
  392.   point q = s.end().translate(s.angle() + M_PI/2 - acos(d),  -R);
  393.   draw_arc(p,q,r,c);
  394.  }
  395.  
  396.  
  397. void window::draw_edge_arrow(double x0,double y0,double x1,double y1,color c)
  398. { draw_edge_arrow(segment(x0,y0,x1,y1),c); }
  399.  
  400. void window::draw_edge_arrow(const point& p, const point& q, color c)
  401. { draw_edge_arrow(segment(p,q),c); }
  402.  
  403. void window::draw_edge_arrow(const segment& s, color c)
  404. { double  alpha = s.angle();
  405.   point p = s.start().translate(alpha,get_node_width()/scaling);
  406.   point q = s.end().translate(alpha,-get_node_width()/scaling);
  407.   draw_arrow(p,q,c);
  408. }
  409.  
  410.  
  411.  
  412. void window::draw_arc_edge_arrow(double x,double y,double x1,double y1,color c)
  413. { draw_arc_edge_arrow(segment(x,y,x1,y1),c); }
  414.  
  415. void window::draw_arc_edge_arrow(const point& p, const point& q, double r, color c)
  416. { draw_arc_edge_arrow(segment(p,q),r,c); }
  417.  
  418. void window::draw_arc_edge_arrow(const segment& s, double r, color c)
  419. { double R = get_node_width()/scale();
  420.   double d = s.length()/(2*r);
  421.   if (d > 1) return;
  422.   point p = s.start().translate(s.angle() - M_PI/2 + acos(d), R);
  423.   point q = s.end().translate(s.angle() + M_PI/2 - acos(d),  -R);
  424.   draw_arc_arrow(p,q,r,c);
  425.  }
  426.  
  427.  
  428. //------------------------------------------------------------------------------
  429. // WINDOW INPUT
  430. //------------------------------------------------------------------------------
  431.  
  432.  
  433. int window::get_button() 
  434. { double x,y;
  435.   return LEDA_WINDOW::get_button(x,y); 
  436.  }
  437.  
  438. int window::get_button(double& x, double& y) 
  439. { return LEDA_WINDOW::get_button(x,y); }
  440.  
  441. int  window::get_button(point& q)
  442. { double x,y;
  443.   int key = LEDA_WINDOW::get_button(x,y);
  444.   q = point(x,y);
  445.   return key;
  446.  }
  447.  
  448.  
  449. int window::read_mouse()
  450. { double d;
  451.   return LEDA_WINDOW::read_mouse(0,0.0,0.0,d,d);
  452.  }
  453.  
  454. int  window::read_mouse(double& x, double& y)
  455. { return LEDA_WINDOW::read_mouse(0,0.0,0.0,x,y); }
  456.  
  457. int  window::read_mouse(point& q)
  458. { double x,y;
  459.   int key = LEDA_WINDOW::read_mouse(0,0.0,0.0,x,y);
  460.   q = point(x,y);
  461.   return key;
  462.  }
  463.  
  464.  
  465. int  window::read_mouse_seg(double x0, double y0, double& x, double& y)
  466. { return LEDA_WINDOW::read_mouse(1,x0,y0,x,y); }
  467.  
  468. int  window::read_mouse_seg(const point& p, point& q)
  469. { double X,Y;
  470.   int key = LEDA_WINDOW::read_mouse(1,p.xcoord(),p.ycoord(),X,Y);
  471.   q = point(X,Y);
  472.   return key;
  473. }
  474.  
  475.  
  476. int  window::read_mouse_rect(double x0, double y0, double& x, double& y)
  477. { return LEDA_WINDOW::read_mouse(2,x0,y0,x,y); }
  478.  
  479.  
  480. int  window::read_mouse_rect(const point& p, point& q)
  481. { double X,Y;
  482.   int key = LEDA_WINDOW::read_mouse(2,p.xcoord(),p.ycoord(),X,Y);
  483.   q = point(X,Y);
  484.   return key;
  485. }
  486.  
  487.  
  488. int  window::read_mouse_circle(double x0, double y0, double& x, double& y)
  489. { return LEDA_WINDOW::read_mouse(3,x0,y0,x,y); }
  490.  
  491.  
  492. int  window::read_mouse_circle(const point& p, point& q)
  493. { double X,Y;
  494.   int key = LEDA_WINDOW::read_mouse(3,p.xcoord(),p.ycoord(),X,Y);
  495.   q = point(X,Y);
  496.   return key;
  497. }
  498.  
  499.  
  500.  
  501. int window::read_mouse_action(mouse_action_func_ptr f, double& x, double& y)
  502. { return LEDA_WINDOW::read_mouse_action(f,0.0,0.0,x,y); }
  503.  
  504.  
  505. int window::read_mouse_action(mouse_action_func_ptr f, point& q)
  506. { double X,Y;
  507.   int key = LEDA_WINDOW::read_mouse_action(f,0.0,0.0,X,Y);
  508.   q = point(X,Y);
  509.   return key;
  510. }
  511.  
  512.  
  513.  
  514. window& window::read(point& p)
  515. { double x,y;
  516.   state = 1;
  517.   int k;
  518.   while ((k = read_mouse(x,y)) != 1) 
  519.    if (k == 3) 
  520.     { state = 0;
  521.       return *this;
  522.      }
  523.   p = point(x,y);
  524.   return *this;
  525.  }
  526.  
  527.  
  528. window& window::read(segment& s)
  529. { double x,y;
  530.   point p;
  531.   int key = 0;
  532.   state = 1;
  533.  
  534.   if (!read(p).state) 
  535.    return *this;
  536.  
  537.   while ((key=read_mouse_seg(p.xcoord(),p.ycoord(),x,y)) != 1)
  538.   { if (key== 3)  
  539.      { state = 0;
  540.        break; 
  541.       }
  542.  
  543.     if (key==-1)
  544.       if (!read(p).state) break;
  545.    }
  546.  
  547.    if (state) s = segment(p.xcoord(),p.ycoord(),x,y);
  548.  
  549.   return *this;
  550. }
  551.  
  552. window& window::read(line& l)
  553. { segment s;
  554.   state = 1;
  555.   read(s);
  556.   if (state) l = line(s);
  557.   return *this;
  558.  }
  559.  
  560.  
  561. window& window::read(circle& c)
  562. { double x,y;
  563.   point p;
  564.   int key = 0;
  565.   state = 1;
  566.  
  567.   if (!read(p).state) 
  568.    return *this;
  569.  
  570.   drawing_mode save = set_mode(xor_mode);
  571.   draw(p);
  572.  
  573.   while ((key=read_mouse_circle(p.xcoord(),p.ycoord(),x,y)) != 1)
  574.   { if (key== 3)  
  575.      { state = 0;
  576.        break; 
  577.       }
  578.  
  579.     if (key==-1)
  580.     { draw(p);
  581.       if (!read(p).state) break;
  582.       draw(p);
  583.      }
  584.    }
  585.    if (state) 
  586.    { double dx = x-p.xcoord();
  587.      double dy = y-p.ycoord();
  588.      c = circle(p,hypot(dx,dy));
  589.      draw(p);
  590.     }
  591.  
  592.   set_mode(save);
  593.   return *this;
  594. }
  595.  
  596. window& window::read(polygon& P)
  597. { double x,y;
  598.   int key = 0;
  599.   state = 1;
  600.   point first,last,p;
  601.   list<point> pl;
  602.  
  603.   if (!read(first).state) return *this;
  604.  
  605.   pl.append(first);
  606.  
  607.   p = first;
  608.  
  609.   drawing_mode save = set_mode(xor_mode);
  610.  
  611.   while ((key = read_mouse_seg(p.xcoord(),p.ycoord(),x,y)) !=2)
  612.   { 
  613.     if (key==3) break;
  614.  
  615.     if (key==-1 && pl.length() > 1 ) 
  616.     { point l = pl.Pop();
  617.       draw_segment(pl.tail(),l);
  618.       p = pl.tail();
  619.      }
  620.  
  621.     if (key==1)
  622.     { point q(x,y);
  623.       draw_segment(p,q);
  624.       pl.append(q);
  625.       p = q;
  626.      }
  627.   }
  628.  
  629.  
  630.   draw_segment(first,p);
  631.  
  632.   list_item it;
  633.   forall_items(it,pl) draw_segment(pl[it],pl[pl.cyclic_succ(it)]);
  634.  
  635.  
  636.   P = polygon(pl);
  637.  
  638.   if (key==3)
  639.   { state = 0;
  640.     Clear(P);
  641.     Init(P);
  642.    }
  643.  
  644.   set_mode(save);
  645.  
  646.   return *this;
  647.  
  648. }
  649.  
  650.  
  651. window& window::operator>>(point& p)    
  652. { set_frame_label(">> POINT");
  653.   read(p); 
  654.   reset_frame_label();
  655.   return *this; 
  656.  }
  657.  
  658. window& window::operator>>(segment& s)  
  659. { set_frame_label(">> SEGMENT");
  660.   read(s); 
  661.   reset_frame_label();
  662.   return *this; 
  663.  }
  664.  
  665. window& window::operator>>(line& l)     
  666. { set_frame_label(">> LINE");
  667.   read(l); 
  668.   reset_frame_label();
  669.   return *this; 
  670.  }
  671.  
  672. window& window::operator>>(circle& C)   
  673. { set_frame_label(">> CIRCLE");
  674.   read(C); 
  675.   reset_frame_label();
  676.   return *this; 
  677.  }
  678.  
  679. window& window::operator>>(polygon& P)  
  680. { set_frame_label(">> POLYGON");
  681.   read(P); 
  682.   reset_frame_label();
  683.   return *this; 
  684.  }
  685.  
  686.  
  687.  
  688.  
  689. int window::confirm(string s)
  690. { panel p;
  691.   p.text_item(s);
  692.   p.button("YES");
  693.   p.button("NO");
  694.   return 1 - p.open();
  695. }
  696.  
  697.  
  698. void window::acknowledge(string s)
  699. { panel p;
  700.   p.text_item(s);
  701.   p.button("CONTINUE");
  702.   p.open();
  703. }
  704.  
  705. void window::notice(string s)
  706. { panel p;
  707.   p.text_item(s);
  708.   p.button("CONTINUE");
  709.   p.open();
  710. }
  711.  
  712.  
  713. int  window::read_panel(string header, int n, string* L)
  714. { panel P("LEDA PANEL");
  715.   P.text_item(header);
  716.   for(int i = 0; i < n; i++) P.button(L[i]);
  717.   return P.open();
  718.  }
  719.  
  720.  
  721. int  window::read_vpanel(string header, int n, string* L)
  722. { panel P("LEDA PANEL");
  723.   P.text_item(header);
  724.   for(int i = 0; i < n; i++) 
  725.   { P.button(L[i]);
  726.     P.new_button_line();
  727.    }
  728.   return P.open();
  729.  }
  730.  
  731.  
  732. string  window::read_string(string prompt)
  733. { panel P("STRING INPUT PANEL");
  734.   string s;
  735.   P.string_item(prompt,s);
  736.   P.open();
  737.   return s;
  738.  }
  739.  
  740. int  window::read_int(string prompt)
  741. { panel P("INT INPUT PANEL");
  742.   int i;
  743.   P.int_item(prompt,i);
  744.   P.open();
  745.   return i;
  746. }
  747.  
  748. double  window::read_real(string prompt)
  749. { panel P("DOUBLE INPUT PANEL");
  750.   double x;
  751.   P.real_item(prompt,x);
  752.   P.open();
  753.   return x;
  754.  }
  755.